#include "Cases.h"
#include "Unite.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void InitialisationCases(Cases *c)
{
	(*c).lunite = NULL;
	(*c).type_decor = 0;    
	(*c).groupe_decor = 0; 
	(*c).vie = 100;
}

void DestructionCases(Cases *c)
{
	if ((*c).lunite != NULL)
	{
		DestructionUnite((*c).lunite);
		free((*c).lunite);
	}
	(*c).type_decor = 0;
	(*c).groupe_decor = 0;
	(*c).vie = 0;
	(*c).lunite = NULL;
}

void DeplacementUniteCases (Cases * cdepart, Cases * cfin)
{
	assert( (*cdepart).lunite != NULL);
	assert( (*cfin).lunite == NULL);
	(*cfin).lunite = (*cdepart).lunite;
	(*cdepart).lunite = NULL;
}

int ActionUniteCases(Cases * u,Cases * element,int action)
{
	int resultat;
	assert( (*u).lunite != NULL);
	if (action == 1) /* Couper du bois */
	{
		(*element).vie = (*element).vie - 50;
		if ((*element).vie <= 0)
		{
			ModificationDecor (element, 0,0);
		}
	}
	else if (action == 2) /* Faire un combat */
	{
		assert( (*element).lunite != NULL);
		resultat = CombatUnite((*u).lunite,(*element).lunite);
		if (resultat == 1)
		{
			DestructionUniteCases(element);
			return 2;
		}
		if (resultat == 2)
		{
			DestructionUniteCases(u);
			return 1;
		}
	}
	return 0;
}

void ModificationDecor (Cases * c, int type, int equipe)
{
	(*c).type_decor = type;
	(*c).vie = 100;
	(*c).groupe_decor = equipe;
}

void DestructionUniteCases (Cases * c)
{
	DestructionUnite((*c).lunite);
	free ((*c).lunite);
	(*c).lunite = NULL;
}

void CreationUniteCases (Cases * c, int type, int equipe)
{
	(*c).lunite = (Unite*) malloc (sizeof (Unite));
	InitialisationUnite((*c).lunite,type,equipe);
}

void CasesTestRegression()
{
	Cases * ctest = (Cases*) malloc(sizeof (Cases));
	Cases * ctest2 = (Cases*) malloc(sizeof (Cases));
	int retour;

	/* Vérification de la procédure InitialisationCases */
	InitialisationCases(ctest);
	assert( (*ctest).lunite == NULL);
	assert( (*ctest).type_decor == 0);
	assert( (*ctest).groupe_decor == 0);
	assert( (*ctest).vie == 100);
	printf("Procédure InitialisationCases ok \n");

	/* Vérification de la procédure DestructionCases */
	DestructionCases(ctest);
	assert( (*ctest).type_decor == 0);
	assert( (*ctest).groupe_decor == 0);
	assert( (*ctest).vie == 0);
	assert( (*ctest).lunite == NULL);
	printf("Procédure DestructionCases ok \n");

	/* Vérification de la procédure ModificationDecor */
	InitialisationCases(ctest);
	ModificationDecor (ctest, 1, 1);
	assert( (*ctest).type_decor == 1);
	assert( (*ctest).groupe_decor == 1);
	assert( (*ctest).vie == 100);
	printf("Procédure ModificationDecor ok \n");
	
	/* Vérification de la procédure CreationUniteCases */
	InitialisationCases(ctest);
	CreationUniteCases (ctest, 1, 1);
	assert( (*ctest).lunite != NULL);
	printf("Procédure CreationUniteCases ok \n");
	
	/* Vérification de la procédure DestructionUniteCases */
	DestructionUniteCases(ctest);
	assert( (*ctest).lunite == NULL);
	printf("Procédure DestructionUniteCases ok \n");
	
	/* Vérification de la procédure DeplacementUniteCases */
	InitialisationCases(ctest2);
	CreationUniteCases (ctest, 1, 1);
	DeplacementUniteCases(ctest, ctest2);
	assert( (*ctest).lunite == NULL);
	assert( (*ctest2).lunite != NULL);
	DestructionUniteCases(ctest2);
	printf("Procédure DeplacementUniteCases ok \n");
	
	/* Vérification de la procédure ActionUniteCases */
	/* test passant dans la boucle if (action == 1) */
	InitialisationCases(ctest);
	InitialisationCases(ctest2);
	CreationUniteCases (ctest, 1, 0);
	ModificationDecor (ctest2, 1, 0);
	retour = ActionUniteCases(ctest,ctest2,1);
	assert( (*ctest2).vie == 50);
	assert( retour == 0);
	retour = ActionUniteCases(ctest,ctest2,1);
	assert( retour == 0);
	assert( (*ctest2).vie == 100);
	assert( (*ctest2).type_decor == 0);
	assert( (*ctest2).groupe_decor == 0);
	DestructionUniteCases(ctest);
	
	/* test passant dans la boucle if (action == 2) 
		L'unité de la case ctest gagne le combat */
	InitialisationCases(ctest);
	InitialisationCases(ctest2);
	CreationUniteCases (ctest, 5, 0);
	CreationUniteCases (ctest2, 3, 1);
	retour = ActionUniteCases(ctest,ctest2,2);
	assert( retour == 0);
	assert( (*(*ctest2).lunite).vie < 100);
	retour = ActionUniteCases(ctest,ctest2,2);
	assert( retour == 2);
	assert( (*ctest2).lunite == NULL);
	DestructionUniteCases(ctest);
	
	/* L'unité de la case ctest2 gagne le combat */	
	InitialisationCases(ctest);
	InitialisationCases(ctest2);
	CreationUniteCases (ctest, 3, 0);
	CreationUniteCases (ctest2, 5, 1);
	retour = ActionUniteCases(ctest,ctest2,2);
	assert( retour == 0);
	assert( (*(*ctest).lunite).vie < 100);
	retour = ActionUniteCases(ctest,ctest2,2);
	assert( retour == 1);
	assert( (*ctest).lunite == NULL);
	printf("Procédure ActionUniteCases ok \n");

	DestructionUniteCases(ctest2);
	
	free(ctest);
	free(ctest2);
	
}
